#include "fpsp-namespace.h"
//
//
//	decbin.sa 3.3 12/19/90
//
//	Description: Converts normalized packed bcd value pointed to by
//	register A6 to extended-precision value in FP0.
//
//	Input: Normalized packed bcd value in ETEMP(a6).
//
//	Output:	Exact floating-point representation of the packed bcd value.
//
//	Saves and Modifies: D2-D5
//
//	Speed: The program decbin takes ??? cycles to execute.
//
//	Object Size:
//
//	External Reference(s): None.
//
//	Algorithm:
//	Expected is a normal bcd (i.e. non-exceptional; all inf, zero,
//	and NaN operands are dispatched without entering this routine)
//	value in 68881/882 format at location ETEMP(A6).
//
//	A1.	Convert the bcd exponent to binary by successive adds and muls.
//	Set the sign according to SE. Subtract 16 to compensate
//	for the mantissa which is to be interpreted as 17 integer
//	digits, rather than 1 integer and 16 fraction digits.
//	Note: this operation can never overflow.
//
//	A2. Convert the bcd mantissa to binary by successive
//	adds and muls in FP0. Set the sign according to SM.
//	The mantissa digits will be converted with the decimal point
//	assumed following the least-significant digit.
//	Note: this operation can never overflow.
//
//	A3. Count the number of leading/trailing zeros in the
//	bcd string.  If SE is positive, count the leading zeros;
//	if negative, count the trailing zeros.  Set the adjusted
//	exponent equal to the exponent from A1 and the zero count
//	added if SM = 1 and subtracted if SM = 0.  Scale the
//	mantissa the equivalent of forcing in the bcd value:
//
//	SM = 0	a non-zero digit in the integer position
//	SM = 1	a non-zero digit in Mant0, lsd of the fraction
//
//	this will insure that any value, regardless of its
//	representation (ex. 0.1E2, 1E1, 10E0, 100E-1), is converted
//	consistently.
//
//	A4. Calculate the factor 10^exp in FP1 using a table of
//	10^(2^n) values.  To reduce the error in forming factors
//	greater than 10^27, a directed rounding scheme is used with
//	tables rounded to RN, RM, and RP, according to the table
//	in the comments of the pwrten section.
//
//	A5. Form the final binary number by scaling the mantissa by
//	the exponent factor.  This is done by multiplying the
//	mantissa in FP0 by the factor in FP1 if the adjusted
//	exponent sign is positive, and dividing FP0 by FP1 if
//	it is negative.
//
//	Clean up and return.  Check if the final mul or div resulted
//	in an inex2 exception.  If so, set inex1 in the fpsr and
//	check if the inex1 exception is enabled.  If so, set d7 upper
//	word to $0100.  This will signal unimp.sa that an enabled inex1
//	exception occurred.  Unimp will fix the stack.
//

//		Copyright (C) Motorola, Inc. 1990
//			All Rights Reserved
//
//	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
//	The copyright notice above does not evidence any
//	actual or intended publication of such source code.

//DECBIN    idnt    2,1 | Motorola 040 Floating Point Software Package

	|section	8

#include "fpsp.defs"

//
//	PTENRN, PTENRM, and PTENRP are arrays of powers of 10 rounded
//	to nearest, minus, and plus, respectively.  The tables include
//	10**{1,2,4,8,16,32,64,128,256,512,1024,2048,4096}.  No rounding
//	is required until the power is greater than 27, however, all
//	tables include the first 5 for ease of indexing.
//
	|xref	PTENRN
	|xref	PTENRM
	|xref	PTENRP

RTABLE:	.byte	0,0,0,0
	.byte	2,3,2,3
	.byte	2,3,3,2
	.byte	3,2,2,3

	.global	decbin
	.global	calc_e
	.global	pwrten
	.global	calc_m
	.global	norm
	.global	ap_st_z
	.global	ap_st_n
//
	.set	FNIBS,7
	.set	FSTRT,0
//
	.set	ESTRT,4
	.set	EDIGITS,2	//
//
// Constants in single precision
FZERO: 	.long	0x00000000
FONE: 	.long	0x3F800000
FTEN: 	.long	0x41200000

	.set	TEN,10

//
decbin:
	| fmovel	#0,FPCR		;clr real fpcr
	moveml	%d2-%d5,-(%a7)
//
// Calculate exponent:
//  1. Copy bcd value in memory for use as a working copy.
//  2. Calculate absolute value of exponent in d1 by mul and add.
//  3. Correct for exponent sign.
//  4. Subtract 16 to compensate for interpreting the mant as all integer digits.
//     (i.e., all digits assumed left of the decimal point.)
//
// Register usage:
//
//  calc_e:
//	(*)  d0: temp digit storage
//	(*)  d1: accumulator for binary exponent
//	(*)  d2: digit count
//	(*)  d3: offset pointer
//	( )  d4: first word of bcd
//	( )  a0: pointer to working bcd value
//	( )  a6: pointer to original bcd value
//	(*)  FP_SCR1: working copy of original bcd value
//	(*)  L_SCR1: copy of original exponent word
//
calc_e:
	movel	#EDIGITS,%d2	//# of nibbles (digits) in fraction part
	moveql	#ESTRT,%d3	//counter to pick up digits
	leal	FP_SCR1(%a6),%a0	//load tmp bcd storage address
	movel	ETEMP(%a6),(%a0)	//save input bcd value
	movel	ETEMP_HI(%a6),4(%a0) //save words 2 and 3
	movel	ETEMP_LO(%a6),8(%a0) //and work with these
	movel	(%a0),%d4	//get first word of bcd
	clrl	%d1		//zero d1 for accumulator
e_gd:
	mulul	#TEN,%d1	//mul partial product by one digit place
	bfextu	%d4{%d3:#4},%d0	//get the digit and zero extend into d0
	addl	%d0,%d1		//d1 = d1 + d0
	addqb	#4,%d3		//advance d3 to the next digit
	dbf	%d2,e_gd	//if we have used all 3 digits, exit loop
	btst	#30,%d4		//get SE
	beqs	e_pos		//don't negate if pos
	negl	%d1		//negate before subtracting
e_pos:
	subl	#16,%d1		//sub to compensate for shift of mant
	bges	e_save		//if still pos, do not neg
	negl	%d1		//now negative, make pos and set SE
	orl	#0x40000000,%d4	//set SE in d4,
	orl	#0x40000000,(%a0)	//and in working bcd
e_save:
	movel	%d1,L_SCR1(%a6)	//save exp in memory
//
//
// Calculate mantissa:
//  1. Calculate absolute value of mantissa in fp0 by mul and add.
//  2. Correct for mantissa sign.
//     (i.e., all digits assumed left of the decimal point.)
//
// Register usage:
//
//  calc_m:
//	(*)  d0: temp digit storage
//	(*)  d1: lword counter
//	(*)  d2: digit count
//	(*)  d3: offset pointer
//	( )  d4: words 2 and 3 of bcd
//	( )  a0: pointer to working bcd value
//	( )  a6: pointer to original bcd value
//	(*) fp0: mantissa accumulator
//	( )  FP_SCR1: working copy of original bcd value
//	( )  L_SCR1: copy of original exponent word
//
calc_m:
	moveql	#1,%d1		//word counter, init to 1
	fmoves	FZERO,%fp0	//accumulator
//
//
//  Since the packed number has a long word between the first & second parts,
//  get the integer digit then skip down & get the rest of the
//  mantissa.  We will unroll the loop once.
//
	bfextu	(%a0){#28:#4},%d0	//integer part is ls digit in long word
	faddb	%d0,%fp0		//add digit to sum in fp0
//
//
//  Get the rest of the mantissa.
//
loadlw:
	movel	(%a0,%d1.L*4),%d4	//load mantissa longword into d4
	moveql	#FSTRT,%d3	//counter to pick up digits
	moveql	#FNIBS,%d2	//reset number of digits per a0 ptr
md2b:
	fmuls	FTEN,%fp0	//fp0 = fp0 * 10
	bfextu	%d4{%d3:#4},%d0	//get the digit and zero extend
	faddb	%d0,%fp0	//fp0 = fp0 + digit
//
//
//  If all the digits (8) in that long word have been converted (d2=0),
//  then inc d1 (=2) to point to the next long word and reset d3 to 0
//  to initialize the digit offset, and set d2 to 7 for the digit count;
//  else continue with this long word.
//
	addqb	#4,%d3		//advance d3 to the next digit
	dbf	%d2,md2b		//check for last digit in this lw
nextlw:
	addql	#1,%d1		//inc lw pointer in mantissa
	cmpl	#2,%d1		//test for last lw
	ble	loadlw		//if not, get last one

//
//  Check the sign of the mant and make the value in fp0 the same sign.
//
m_sign:
	btst	#31,(%a0)	//test sign of the mantissa
	beq	ap_st_z		//if clear, go to append/strip zeros
	fnegx	%fp0		//if set, negate fp0

//
// Append/strip zeros:
//
//  For adjusted exponents which have an absolute value greater than 27*,
//  this routine calculates the amount needed to normalize the mantissa
//  for the adjusted exponent.  That number is subtracted from the exp
//  if the exp was positive, and added if it was negative.  The purpose
//  of this is to reduce the value of the exponent and the possibility
//  of error in calculation of pwrten.
//
//  1. Branch on the sign of the adjusted exponent.
//  2p.(positive exp)
//   2. Check M16 and the digits in lwords 2 and 3 in descending order.
//   3. Add one for each zero encountered until a non-zero digit.
//   4. Subtract the count from the exp.
//   5. Check if the exp has crossed zero in #3 above; make the exp abs
//	   and set SE.
//	6. Multiply the mantissa by 10**count.
//  2n.(negative exp)
//   2. Check the digits in lwords 3 and 2 in descending order.
//   3. Add one for each zero encountered until a non-zero digit.
//   4. Add the count to the exp.
//   5. Check if the exp has crossed zero in #3 above; clear SE.
//   6. Divide the mantissa by 10**count.
//
//  *Why 27?  If the adjusted exponent is within -28 < expA < 28, than
//   any adjustment due to append/strip zeros will drive the resultant
//   exponent towards zero.  Since all pwrten constants with a power
//   of 27 or less are exact, there is no need to use this routine to
//   attempt to lessen the resultant exponent.
//
// Register usage:
//
//  ap_st_z:
//	(*)  d0: temp digit storage
//	(*)  d1: zero count
//	(*)  d2: digit count
//	(*)  d3: offset pointer
//	( )  d4: first word of bcd
//	(*)  d5: lword counter
//	( )  a0: pointer to working bcd value
//	( )  FP_SCR1: working copy of original bcd value
//	( )  L_SCR1: copy of original exponent word
//
//
// First check the absolute value of the exponent to see if this
// routine is necessary.  If so, then check the sign of the exponent
// and do append (+) or strip (-) zeros accordingly.
// This section handles a positive adjusted exponent.
//
ap_st_z:
	movel	L_SCR1(%a6),%d1	//load expA for range test
	cmpl	#27,%d1		//test is with 27
	ble	pwrten		//if abs(expA) <28, skip ap/st zeros
	btst	#30,(%a0)	//check sign of exp
	bne	ap_st_n		//if neg, go to neg side
	clrl	%d1		//zero count reg
	movel	(%a0),%d4		//load lword 1 to d4
	bfextu	%d4{#28:#4},%d0	//get M16 in d0
	bnes	ap_p_fx		//if M16 is non-zero, go fix exp
	addql	#1,%d1		//inc zero count
	moveql	#1,%d5		//init lword counter
	movel	(%a0,%d5.L*4),%d4	//get lword 2 to d4
	bnes	ap_p_cl		//if lw 2 is zero, skip it
	addql	#8,%d1		//and inc count by 8
	addql	#1,%d5		//inc lword counter
	movel	(%a0,%d5.L*4),%d4	//get lword 3 to d4
ap_p_cl:
	clrl	%d3		//init offset reg
	moveql	#7,%d2		//init digit counter
ap_p_gd:
	bfextu	%d4{%d3:#4},%d0	//get digit
	bnes	ap_p_fx		//if non-zero, go to fix exp
	addql	#4,%d3		//point to next digit
	addql	#1,%d1		//inc digit counter
	dbf	%d2,ap_p_gd	//get next digit
ap_p_fx:
	movel	%d1,%d0		//copy counter to d2
	movel	L_SCR1(%a6),%d1	//get adjusted exp from memory
	subl	%d0,%d1		//subtract count from exp
	bges	ap_p_fm		//if still pos, go to pwrten
	negl	%d1		//now its neg; get abs
	movel	(%a0),%d4		//load lword 1 to d4
	orl	#0x40000000,%d4	// and set SE in d4
	orl	#0x40000000,(%a0)	// and in memory
//
// Calculate the mantissa multiplier to compensate for the striping of
// zeros from the mantissa.
//
ap_p_fm:
	movel	#PTENRN,%a1	//get address of power-of-ten table
	clrl	%d3		//init table index
	fmoves	FONE,%fp1	//init fp1 to 1
	moveql	#3,%d2		//init d2 to count bits in counter
ap_p_el:
	asrl	#1,%d0		//shift lsb into carry
	bccs	ap_p_en		//if 1, mul fp1 by pwrten factor
	fmulx	(%a1,%d3),%fp1	//mul by 10**(d3_bit_no)
ap_p_en:
	addl	#12,%d3		//inc d3 to next rtable entry
	tstl	%d0		//check if d0 is zero
	bnes	ap_p_el		//if not, get next bit
	fmulx	%fp1,%fp0		//mul mantissa by 10**(no_bits_shifted)
	bra	pwrten		//go calc pwrten
//
// This section handles a negative adjusted exponent.
//
ap_st_n:
	clrl	%d1		//clr counter
	moveql	#2,%d5		//set up d5 to point to lword 3
	movel	(%a0,%d5.L*4),%d4	//get lword 3
	bnes	ap_n_cl		//if not zero, check digits
	subl	#1,%d5		//dec d5 to point to lword 2
	addql	#8,%d1		//inc counter by 8
	movel	(%a0,%d5.L*4),%d4	//get lword 2
ap_n_cl:
	movel	#28,%d3		//point to last digit
	moveql	#7,%d2		//init digit counter
ap_n_gd:
	bfextu	%d4{%d3:#4},%d0	//get digit
	bnes	ap_n_fx		//if non-zero, go to exp fix
	subql	#4,%d3		//point to previous digit
	addql	#1,%d1		//inc digit counter
	dbf	%d2,ap_n_gd	//get next digit
ap_n_fx:
	movel	%d1,%d0		//copy counter to d0
	movel	L_SCR1(%a6),%d1	//get adjusted exp from memory
	subl	%d0,%d1		//subtract count from exp
	bgts	ap_n_fm		//if still pos, go fix mantissa
	negl	%d1		//take abs of exp and clr SE
	movel	(%a0),%d4		//load lword 1 to d4
	andl	#0xbfffffff,%d4	// and clr SE in d4
	andl	#0xbfffffff,(%a0)	// and in memory
//
// Calculate the mantissa multiplier to compensate for the appending of
// zeros to the mantissa.
//
ap_n_fm:
	movel	#PTENRN,%a1	//get address of power-of-ten table
	clrl	%d3		//init table index
	fmoves	FONE,%fp1	//init fp1 to 1
	moveql	#3,%d2		//init d2 to count bits in counter
ap_n_el:
	asrl	#1,%d0		//shift lsb into carry
	bccs	ap_n_en		//if 1, mul fp1 by pwrten factor
	fmulx	(%a1,%d3),%fp1	//mul by 10**(d3_bit_no)
ap_n_en:
	addl	#12,%d3		//inc d3 to next rtable entry
	tstl	%d0		//check if d0 is zero
	bnes	ap_n_el		//if not, get next bit
	fdivx	%fp1,%fp0		//div mantissa by 10**(no_bits_shifted)
//
//
// Calculate power-of-ten factor from adjusted and shifted exponent.
//
// Register usage:
//
//  pwrten:
//	(*)  d0: temp
//	( )  d1: exponent
//	(*)  d2: {FPCR[6:5],SM,SE} as index in RTABLE; temp
//	(*)  d3: FPCR work copy
//	( )  d4: first word of bcd
//	(*)  a1: RTABLE pointer
//  calc_p:
//	(*)  d0: temp
//	( )  d1: exponent
//	(*)  d3: PWRTxx table index
//	( )  a0: pointer to working copy of bcd
//	(*)  a1: PWRTxx pointer
//	(*) fp1: power-of-ten accumulator
//
// Pwrten calculates the exponent factor in the selected rounding mode
// according to the following table:
//
//	Sign of Mant  Sign of Exp  Rounding Mode  PWRTEN Rounding Mode
//
//	ANY	  ANY	RN	RN
//
//	 +	   +	RP	RP
//	 -	   +	RP	RM
//	 +	   -	RP	RM
//	 -	   -	RP	RP
//
//	 +	   +	RM	RM
//	 -	   +	RM	RP
//	 +	   -	RM	RP
//	 -	   -	RM	RM
//
//	 +	   +	RZ	RM
//	 -	   +	RZ	RM
//	 +	   -	RZ	RP
//	 -	   -	RZ	RP
//
//
pwrten:
	movel	USER_FPCR(%a6),%d3 //get user's FPCR
	bfextu	%d3{#26:#2},%d2	//isolate rounding mode bits
	movel	(%a0),%d4		//reload 1st bcd word to d4
	asll	#2,%d2		//format d2 to be
	bfextu	%d4{#0:#2},%d0	// {FPCR[6],FPCR[5],SM,SE}
	addl	%d0,%d2		//in d2 as index into RTABLE
	leal	RTABLE,%a1	//load rtable base
	moveb	(%a1,%d2),%d0	//load new rounding bits from table
	clrl	%d3			//clear d3 to force no exc and extended
	bfins	%d0,%d3{#26:#2}	//stuff new rounding bits in FPCR
	fmovel	%d3,%FPCR		//write new FPCR
	asrl	#1,%d0		//write correct PTENxx table
	bccs	not_rp		//to a1
	leal	PTENRP,%a1	//it is RP
	bras	calc_p		//go to init section
not_rp:
	asrl	#1,%d0		//keep checking
	bccs	not_rm
	leal	PTENRM,%a1	//it is RM
	bras	calc_p		//go to init section
not_rm:
	leal	PTENRN,%a1	//it is RN
calc_p:
	movel	%d1,%d0		//copy exp to d0;use d0
	bpls	no_neg		//if exp is negative,
	negl	%d0		//invert it
	orl	#0x40000000,(%a0)	//and set SE bit
no_neg:
	clrl	%d3		//table index
	fmoves	FONE,%fp1	//init fp1 to 1
e_loop:
	asrl	#1,%d0		//shift next bit into carry
	bccs	e_next		//if zero, skip the mul
	fmulx	(%a1,%d3),%fp1	//mul by 10**(d3_bit_no)
e_next:
	addl	#12,%d3		//inc d3 to next rtable entry
	tstl	%d0		//check if d0 is zero
	bnes	e_loop		//not zero, continue shifting
//
//
//  Check the sign of the adjusted exp and make the value in fp0 the
//  same sign. If the exp was pos then multiply fp1*fp0;
//  else divide fp0/fp1.
//
// Register Usage:
//  norm:
//	( )  a0: pointer to working bcd value
//	(*) fp0: mantissa accumulator
//	( ) fp1: scaling factor - 10**(abs(exp))
//
norm:
	btst	#30,(%a0)	//test the sign of the exponent
	beqs	mul		//if clear, go to multiply
div:
	fdivx	%fp1,%fp0		//exp is negative, so divide mant by exp
	bras	end_dec
mul:
	fmulx	%fp1,%fp0		//exp is positive, so multiply by exp
//
//
// Clean up and return with result in fp0.
//
// If the final mul/div in decbin incurred an inex exception,
// it will be inex2, but will be reported as inex1 by get_op.
//
end_dec:
	fmovel	%FPSR,%d0		//get status register
	bclrl	#inex2_bit+8,%d0	//test for inex2 and clear it
	fmovel	%d0,%FPSR		//return status reg w/o inex2
	beqs	no_exc		//skip this if no exc
	orl	#inx1a_mask,USER_FPSR(%a6) //set inex1/ainex
no_exc:
	moveml	(%a7)+,%d2-%d5
	rts
	|end
